#include <iostream>
#include "../ser/server.hpp"

// void HandelClose(Chennal *channel)
// {
// //    std::cout<<"Close: " <<channel->getFd()<< std::endl;
//     LOG_DEBUG("Close: %d", channel->getFd());
//    channel->Remove(); //关闭释放
//    delete channel;
// }

// void HandelRead(Chennal *channel)
// {
//     char buffer[1024];
//     int n=recv(channel->getFd(),buffer,1023,0);
//     if(n<0)
//     {
//         std::cout<<"recv error"<<std::endl;
//         return HandelClose(channel); //关闭释放
//     }
//     buffer[n]='\0';
//     // std::cout<<"recv data:"<<buffer<<std::endl;
//     LOG_DEBUG("recv data:%s", buffer);
//     channel->EnableWrite(); //启动可写事件
// }
// void HandelWrite(Chennal *channel)
// {
//     const char *data="hello world";
//     int ret=send(channel->getFd(),data,strlen(data),0);
//     if(ret<0)
//     {
//         std::cout<<"send error"<<std::endl;
//         return HandelClose(channel);
//     }
//     channel->DisableWrite();
// }

// void HandelError(Chennal *channel)
// {
//     return HandelError(channel);//关闭释放
// }
// void HandelEvent(Chennal *channel,uint64_t id,EventLoop* loop)
// {
//     // std::cout<<"有了一个事件"<<std::endl;
//     loop->RefreshTimer(id); //刷新定时器
// }



// void Accept(EventLoop *loop,Chennal *lst_chennel)
// {
//     int fd=lst_chennel->getFd();
//     int newfd=accept(fd,NULL,NULL);
//     if(newfd<0)
//     {
//         std::cout<<"accept error"<<std::endl;
//         return;
//     }
//     uint64_t id=rand()%10000;;
//     Chennal *channel=new Chennal (loop,newfd);
//     channel->SetReadCallback(std::bind(HandelRead,channel)); //为通信套接字设置可读事件的回调函数
//     channel->SetWriteCallback(std::bind(HandelWrite,channel)); //为通信套接字设置可写事件的回调函数
//     channel->SetCloseCallback(std::bind(HandelClose,channel)); //为通信套接字设置关闭事件的回调函数
//     channel->SetErrorCallback(std::bind(HandelError,channel)); //为通信套接字设置错误事件的回调函数
//     channel->SetEventCallback(std::bind(HandelEvent,channel,id,loop)); //为通信套接字设置事件事件的回调函数
//     channel->EnableRead();

//     //添加一个非活跃销毁任务
//     loop->AddTimer(id,10,std::bind(HandelClose,channel)); //添加一个10秒的定时器，用于关闭通信套接字
// }

// int main()
// {
//     //生成随机数
//     srand(time(NULL));
//     EventLoop loop;
//     Socket list_sock;
//     list_sock.CreateServer(8080);
//     //为监听套件字,创建一个Chennal进行事件管理，以及事件的处理
//     Chennal chennal(&loop,list_sock.GetFd());
//     //回调中，获取新连接，为新连接创建Chennal并添加监控
//     chennal.SetReadCallback(std::bind(Accept,&loop,&chennal));
//     //启动可读事件监控
//     chennal.EnableRead();
//     while (1)
//     {
//        loop.Start();//启动事件循环

//     }
//     list_sock.Close();
//     return 0;
// }



// uint64_t id=0;

// std::unordered_map<uint64_t, PtrConnection> _connections;

// void ConnectionDestroy(PtrConnection con)
// {
//     _connections.erase(con->GetConnId());
// }

// void OnMessage(PtrConnection con,Buffer *buf)
// {
//    LOG_DEBUG("recv data:%s",buf->current_read_pos());
//    buf->move_read_pos(buf->readable_size());
//    std::string str="hello world";
//    con->Send(str.c_str(),str.size());
//    con->Shutdown();
// }

// void OnConnected(PtrConnection con)
// {
//     // std::cout<<"连接成功"<<std::endl;
//     LOG_DEBUG("New connection:%p",con.get());
// }

// void Accept(EventLoop *loop,Chennal *lst_chennel)
// {
//     int fd=lst_chennel->getFd();
//     int newfd=accept(fd,NULL,NULL);
//     if(newfd<0)
//     {
//         std::cout<<"accept error"<<std::endl;
//         return;
//     }
//     id++;
//     PtrConnection con(new Connection(loop,id,newfd));
//     con->SetMessageCallback(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2)); 
//     con->SetCloseCallback(std::bind(ConnectionDestroy,std::placeholders::_1)); 
//     con->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1)); 
//     con->EnableInactiveRelease(10);
//     con->Established();
//     _connections.insert(std::make_pair(id,con));
// }

// int main()
// {
//     //生成随机数
//     srand(time(NULL));
//     EventLoop loop;
//     Socket list_sock;
//     list_sock.CreateServer(8080);
//     //为监听套件字,创建一个Chennal进行事件管理，以及事件的处理
//     Chennal chennal(&loop,list_sock.GetFd());
//     //回调中，获取新连接，为新连接创建Chennal并添加监控
//     chennal.SetReadCallback(std::bind(Accept,&loop,&chennal));
//     //启动可读事件监控
//     chennal.EnableRead();
//     while (1)
//     {
//        loop.Start();//启动事件循环

//     }
//     list_sock.Close();
//     return 0;
// }




// uint64_t id=0;

// std::unordered_map<uint64_t, PtrConnection> _connections;
// EventLoop loop;
// void ConnectionDestroy(PtrConnection con)
// {
//     _connections.erase(con->GetConnId());
// }

// void OnMessage(PtrConnection con,Buffer *buf)
// {
//    LOG_DEBUG("recv data:%s",buf->current_read_pos());
//    buf->move_read_pos(buf->readable_size());
//    std::string str="hello world";
//    con->Send(str.c_str(),str.size());
//    con->Shutdown();
// }

// void OnConnected(PtrConnection con)
// {
//     // std::cout<<"连接成功"<<std::endl;
//     LOG_DEBUG("New connection:%p",con.get());
// }

// void Accept(int fd)
// {
//     id++;
//     PtrConnection con(new Connection(&loop,id,fd));
//     con->SetMessageCallback(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2)); 
//     con->SetCloseCallback(std::bind(ConnectionDestroy,std::placeholders::_1)); 
//     con->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1)); 
//     con->EnableInactiveRelease(10);
//     con->Established();
//     _connections.insert(std::make_pair(id,con));
// }

// int main()
// {
//     //生成随机数
//     srand(time(NULL));
//     Acceptor accept(&loop,8080);
//     accept.SetAcceptCallback(std::bind(Accept,std::placeholders::_1));
//     accept.Listen();
//     while (1)
//     {
//        loop.Start();//启动事件循环
//     }
//     return 0;
// }




// uint64_t id=0;

// std::unordered_map<uint64_t, PtrConnection> _connections;
// EventLoop back_loop;
// std::vector<LoopThread> threads(2);
// int thread_num=0;
// void ConnectionDestroy(PtrConnection con)
// {
//     _connections.erase(con->GetConnId());
// }

// void OnMessage(PtrConnection con,Buffer *buf)
// {
//    LOG_DEBUG("recv data:%s",buf->current_read_pos());
//    buf->move_read_pos(buf->readable_size());
//    std::string str="hello world";
//    con->Send(str.c_str(),str.size());
//    con->Shutdown();
// }

// void OnConnected(PtrConnection con)
// {
//     // std::cout<<"连接成功"<<std::endl;
//     LOG_DEBUG("New connection:%p",con.get());
// }

// void Accept(int fd)
// {
//     id++;
//     thread_num=(thread_num+1)%2;
//     PtrConnection con(new Connection(threads[thread_num].GetLoop(),id,fd));
//     con->SetMessageCallback(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2)); 
//     con->SetCloseCallback(std::bind(ConnectionDestroy,std::placeholders::_1)); 
//     con->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1)); 
//     con->EnableInactiveRelease(10);
//     con->Established();
//     _connections.insert(std::make_pair(id,con));

//     LOG_DEBUG("New ------------------------");
// }

// int main()
// {
//     //生成随机数
//     srand(time(NULL));
//     Acceptor accept(&back_loop,8080);
//     accept.SetAcceptCallback(std::bind(Accept,std::placeholders::_1));
//     accept.Listen();
//     while (1)
//     {
//        back_loop.Start();//启动事件循环
//     }
//     return 0;
// }




uint64_t id=0;

std::unordered_map<uint64_t, PtrConnection> _connections;
EventLoop base_loop;
LoopThreadPool* loop_pool;
void ConnectionDestroy(PtrConnection con)
{
    _connections.erase(con->GetConnId());
}

void OnMessage(PtrConnection con,Buffer *buf)
{
   LOG_DEBUG("recv data:%s",buf->current_read_pos());
   buf->move_read_pos(buf->readable_size());
   std::string str="hello world";
   con->Send(str.c_str(),str.size());
   con->Shutdown();
}

void OnConnected(PtrConnection con)
{
    // std::cout<<"连接成功"<<std::endl;
    LOG_DEBUG("New connection:%p",con.get());
}

void Accept(int fd)
{
    id++;
    PtrConnection con(new Connection(loop_pool->NextLoop(),id,fd));
    con->SetMessageCallback(std::bind(OnMessage,std::placeholders::_1,std::placeholders::_2)); 
    con->SetCloseCallback(std::bind(ConnectionDestroy,std::placeholders::_1)); 
    con->SetConnectedCallback(std::bind(OnConnected,std::placeholders::_1)); 
    con->EnableInactiveRelease(10);
    con->Established();
    _connections.insert(std::make_pair(id,con));

    LOG_DEBUG("New ------------------------");
}

int main()
{
    //生成随机数
    srand(time(NULL));

    loop_pool=new LoopThreadPool(&base_loop);
    loop_pool->SetThreadNum(2);
    loop_pool->Create();
    Acceptor accept(&base_loop,8080);
    accept.SetAcceptCallback(std::bind(Accept,std::placeholders::_1));
    accept.Listen();
    base_loop.Start();//启动事件循环
    return 0;
}